home *** CD-ROM | disk | FTP | other *** search
/ BBS in a Box 1 / BBS in a box - Trilogy I.iso / Files / Publish / J-L / lpr / lpr source / format.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-07-18  |  12.2 KB  |  542 lines  |  [TEXT/MPS ]

  1. #if !defined(USEDUMP)
  2.     #include "lprlib.h"
  3.     #include "lprdef.h"
  4.     #include "lprfuncs.h"
  5. #else
  6.     #pragma load "lprDumpFile"
  7. #endif
  8.  
  9. extern unsigned char * filelist;    /* pointer to list of files to process */
  10. extern unsigned char sbuf[];        /* tcp send buffer */
  11. extern short sbuflen;                /* size of send buffer */
  12. extern unsigned char setmsg1[];    
  13. extern unsigned char setmsg2[];    
  14. extern unsigned long filesize;        /* total number of data bytes we send */
  15. extern short prtfcount;                /* count of files printed */
  16. extern settings_list cs, ds;
  17. extern short vnum;                    /* volume number to use */
  18. extern unsigned char countonly;
  19. extern unsigned char pend_conn;        /* connection pending status */
  20. extern unsigned char prtstat[];
  21. unsigned char * currfname;
  22. short currfnum;
  23. FileParam currfp;
  24. unsigned char tt1[81];                /* title lines */
  25. unsigned char tt2[81];
  26. unsigned short pageno;
  27. unsigned char currline[130];
  28. unsigned char fbuf[512];            /* buffer for reading file data */
  29. short fbuflen;                        /* count of characters in fbuf */
  30. short fbufptr;                        /* offset for next character */
  31. unsigned char fileeof;                /* eof flag for newchar */
  32.  
  33. OSErr prtformat(void)
  34. {
  35. short i;
  36. OSErr rc;
  37.  
  38. currfname = filelist;            /* loop through each file */
  39. sbuflen = 0;
  40. rc = 0;
  41. if (countonly) filesize = 0;
  42. while (currfname[0] != 0) {
  43.     i = 0;
  44.     while (currfname[i] != 0x0d) i++;
  45.     if (i == 0) {        /* skip blank lines */
  46.         currfname = currfname + 1;
  47.         continue;
  48.         }
  49.     currfname[i] = 0;        /* terminate name */
  50.     sprintf(setmsg1, "starting new file: \"%s\"", currfname);
  51.     putln(setmsg1);
  52.                                 /* handle control line */
  53.     if (currfname[0] == '#') rc = docontrol(currfname+1);    
  54.     else {                        /* handle file name line */
  55.                         /* prepare first part of error messages */
  56.         sprintf(setmsg1, "Error reading file \"%s\"", currfname);
  57.         memset(&currfp, 0, sizeof(FileParam));
  58.         currfp.ioNamePtr = (StringPtr)currfname;
  59.         currfp.ioVRefNum = vnum;
  60.         c2pstr(currfp.ioNamePtr);
  61.         rc = PBGetFInfo((ParmBlkPtr)&currfp, 0);
  62.         p2cstr(currfp.ioNamePtr);
  63.         if (rc != 0) {
  64.             sprintf(setmsg2, "Error %d getting file info", rc);
  65.             seterr();
  66.             }
  67.         else {
  68.             rc = fsrdopen(currfname, vnum, &currfnum);
  69.             if (rc != 0) {
  70.                 sprintf(setmsg2, "Error %d opening file", rc);
  71.                 seterr();
  72.                 }
  73.             else {
  74.                 if (prtfcount == 0) {
  75.                     rc = dofile(1);        /* no form feed at beginning */
  76.                     }
  77.                 else {
  78.                     rc = dofile(cs.noff);
  79.                     }
  80.                 prtfcount++;
  81.                 FSClose(currfnum);
  82.                 }
  83.             }
  84.         }
  85.     currfname[i] = 0x0d;
  86.     if (rc != 0) break;
  87.     currfname = currfname + i + 1;
  88.     if (countonly) {
  89.         sprintf(setmsg1, "filesize = %ld", filesize);
  90.         putln(setmsg1);
  91.         }
  92.     }
  93.             /* if still connected, attempt to send remaining data, */
  94.             /* followd by null */
  95. if (countonly || (pend_conn == 0)) return(rc);
  96. sbuf[sbuflen++] = 0x00;
  97. tcpwrite(sbuf, sbuflen);
  98. sbuflen = 0;
  99. if (pend_conn == 0) if (rc == 0) rc = 8;
  100. return(rc);
  101. }
  102.  
  103. OSErr docontrol(s)
  104. unsigned char * s;
  105. {
  106. sprintf(setmsg2, "docontrol data: \"%s\"", s);
  107. putln(setmsg2);
  108. return(0);
  109. }
  110.  
  111. OSErr dofile(char noff)
  112. {
  113. OSErr rc;
  114. unsigned long eofsize, readsize, readact;
  115. unsigned char byte1;
  116. unsigned short i, wrc;
  117. unsigned short lineno;
  118. unsigned short top, pgsize;
  119.  
  120. if (countonly) {
  121.     sprintf(prtstat, "Calculating size of \"%s\"", currfname);
  122.     statdlg(0, 0x04);
  123.     }
  124. else {
  125.     sprintf(prtstat, "Sending \"%s\" to host", currfname);
  126.     statdlg(0, 0x04);
  127.     }
  128.  
  129. if (cs.fmttype != 2) {                /* print file without doing formatting */
  130.                             /* get size of file */
  131.     rc = GetEOF(currfnum, (long *)&eofsize);
  132.     if (rc != 0) {
  133.         sprintf(setmsg2, "Error %d getting file size", rc);
  134.         seterr();
  135.         return(rc);
  136.         }
  137.                             /* write initial FF if not suppressed */
  138.     if (!noff) {
  139.         rc = fmtwrite("\014", 1);
  140.         if (rc != 0) return(rc);
  141.         }
  142.                             /* if empty file, write LF and return */
  143.     if (eofsize == 0) {
  144.         return(fmtwrite("\012", 1));
  145.         }
  146.                             /* read first byte */
  147.     readsize = 1;
  148.     rc = FSRead(currfnum, (long *)&readsize, &byte1); 
  149.     if ((rc != 0) || (readsize != 1)) {
  150.         if (rc == 0) rc = 4;
  151.         sprintf(setmsg2, "Error %d reading file", rc);
  152.         seterr();
  153.         return(rc);
  154.         }
  155.     if (byte1 == 0x0d) byte1 = 0x0a;
  156.                         /* write first byte if not FF, or noff set */
  157.     if (noff || (byte1 != 0x0c)) {
  158.         rc = fmtwrite(&byte1, 1);
  159.         if (rc != 0) return(rc);
  160.         }
  161.     eofsize--;
  162.  
  163.     if (countonly) {
  164.         filesize += eofsize;        /* add remaining size of file */
  165.                 /* add LF if file doesn't end with one */
  166.         if (eofsize > 0) {    /* already have last byte if eofsize = 0 */
  167.             rc = SetFPos(currfnum, fsFromLEOF, -1L);
  168.             if (rc != 0) {
  169.                 sprintf(setmsg2, "Error %d setting file position", rc);
  170.                 seterr();
  171.                 return(rc);
  172.                 }
  173.             readsize = 1;
  174.             rc = FSRead(currfnum, (long *)&readsize, &byte1); 
  175.             if ((rc != 0) || (readsize != 1)) {
  176.                 if (rc == 0) rc = 4;
  177.                 sprintf(setmsg2, "Error %d reading file", rc);
  178.                 seterr();
  179.                 return(rc);
  180.                 }
  181.             if (byte1 == 0x0d) byte1 = 0x0a;
  182.             }
  183.         if (byte1 != 0x0a) filesize++;    /* add CR if none at end */
  184.         return(0);
  185.         }
  186.  
  187.     while (eofsize > 0) {            /* write remaining bytes */
  188.         readsize = 512 - sbuflen;
  189.         if (readsize > eofsize) readsize = eofsize;
  190.         eofsize -= readsize;
  191.         readact = readsize;
  192.         rc = FSRead(currfnum, (long *)&readact, sbuf+sbuflen);
  193.         if ((rc != 0) || (readsize != readact)) {
  194.             sprintf(setmsg2, "Error %d reading file", rc);
  195.             seterr();
  196.             return(rc);
  197.             }
  198.         for (i=0; i < readsize; i++)
  199.             if (sbuf[sbuflen+i] == 0x0d) sbuf[sbuflen+i] = 0x0a;
  200.         if (eofsize == 0) byte1 = sbuf[sbuflen+readsize-1];
  201.         sbuflen += readsize;
  202.         if (sbuflen == 512) {
  203.             tcpwrite(sbuf, 512);
  204.             sbuflen = 0;
  205.             if (pend_conn == 0) return(8);
  206.             }
  207.         }
  208.  
  209.     if (byte1 != 0x0a) {
  210.         rc = fmtwrite("\012", 1);
  211.         if (rc != 0) return(rc);
  212.         }
  213.  
  214.     return(0);
  215.     }
  216.  
  217. else {                /* print file with our own formatting */
  218.     top = cs.ftop;                /* get page parameters */
  219.     if (top > 13 - MARGIN) top = 13 - MARGIN;
  220.     pgsize = cs.fpgsize;
  221.     if (pgsize == 0) pgsize = ds.fpgsize;
  222.     if (pgsize < 16) pgsize = 16;
  223.     maketitles();                /* construct titles to use */
  224.     pageno = 0;
  225.     lineno = 0;
  226.     fbuflen = 0;
  227.     fbufptr = 0;
  228.     fileeof = 0;
  229.     wrc = 0;
  230.     while ((rc = getline()) == 0) {
  231.         if (ctlline()) {        /* all control lines start new pages */
  232.             lineno = 0;
  233.             continue;
  234.             }
  235.         if (lineno == 0) {
  236.             if ((pageno > 0) || (prtfcount > 0)) {
  237.                 wrc = fmtwrite("\014", 1);
  238.                 if (wrc != 0) break;
  239.                 }
  240.             wrc = skip(top);
  241.             if (wrc != 0) break;
  242.             pageno = pageno + 1;
  243.             wrc = puthead();
  244.             if (wrc != 0) break;
  245.             wrc = skip(MARGIN);
  246.             if (wrc != 0) break;
  247.             lineno = top + MARGIN + 2;        /* two heading lines */
  248.             }
  249.         wrc = putline();
  250.         if (wrc != 0) break;
  251.         lineno = lineno + 1;
  252.         if (lineno >= pgsize) lineno = 0;
  253.         }
  254.     }
  255.     if (wrc != 0) return(wrc);
  256.     if (cs.duplex) {
  257.         if (pageno%2) {
  258.             lineno = 0;
  259.             wrc = fmtwrite("\014", 1);
  260.             if (wrc != 0) return(wrc);
  261.             wrc = skip(top);
  262.             if (wrc != 0) return(wrc);
  263.             pageno = pageno + 1;
  264.             wrc = puthead();
  265.             if (wrc != 0) return(wrc);
  266.             }
  267.         }
  268.     if (rc == eofErr) return(0);
  269.     else return(rc);
  270. }
  271.  
  272. void maketitles(void)
  273. {
  274. short tlen;
  275. DateTimeRec dtr;
  276. static unsigned char * days[7] = {
  277.     "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"};
  278. static unsigned char * months[12] = {
  279.     "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul",
  280.     "Aug", "Sep", "Oct", "Nov", "Dec"};
  281. static unsigned char am[3] = "AM";
  282. static unsigned char pm[3] = "PM";
  283. unsigned char * timeptr;
  284. short hours;
  285.  
  286.                         /* first line */
  287. memset(tt1, 0x20, 79);
  288. tt1[79] = 0x0a;
  289. tt1[80] = 0;
  290. memcpy(tt1, "File: \"", 7);
  291. tlen = strlen(currfname);
  292. if (tlen > 63) tlen = 63;
  293. memcpy(tt1+7, currfname, tlen);
  294. if (tlen < 63) tt1[tlen+7] = '"';
  295.                         /* second line */
  296. if (cs.fmttitle[0] != 0) {        /* use title given by user */
  297.     tlen = strlen(cs.fmttitle);
  298.     if (tlen > 79) tlen = 79;
  299.     memcpy(tt2, cs.fmttitle, tlen);
  300.     tt2[tlen] = 0x0a;
  301.     tt2[tlen+1] = 0;
  302.     return;
  303.     }
  304.                                 /* generate default title */
  305. Secs2Date(currfp.ioFlMdDat, &dtr);
  306. if (dtr.hour < 12) timeptr = am;
  307. else timeptr = pm;
  308. if (dtr.hour == 0) hours = 12;
  309. else if (dtr.hour > 12) hours = dtr.hour - 12;
  310. else hours = dtr.hour;
  311. sprintf(tt2, "Last Modified: %s, %s %d, %d  %d:%02d:%02d %s\012",
  312. days[dtr.dayOfWeek-1], months[dtr.month-1], dtr.day, dtr.year,
  313. hours, dtr.minute, dtr.second, timeptr);
  314. }
  315.  
  316. short puthead(void)
  317. {
  318. unsigned char pbuff[12];
  319. short i, rc, indent, width;
  320.  
  321. indent = cs.findent;
  322. if (indent > 63) indent = 0;
  323. if (indent > 0) memset(currline, 0x20, indent);
  324.  
  325. width = cs.fwidth;
  326. if (width == 0) width = ds.fwidth;
  327. if (width > 128) width = 128;
  328. if (width < 64) width = 64;
  329.  
  330. memset(tt1+71, 0x20, 8);
  331. if (pageno > 999) sprintf(pbuff, "Page%4d", pageno%10000);
  332. else sprintf(pbuff, "Page %d", pageno);
  333. i = strlen(pbuff);
  334. memcpy(tt1+79-i, pbuff, i); 
  335.  
  336. if (indent > 0) for (i=0; i < indent; i++) {
  337.     rc = fmtwrite(" ", 1);
  338.     if (rc != 0) return(rc);
  339.     }
  340. i = strlen(tt1) - 1;
  341. if (i > width - indent) i = width - indent; 
  342. rc = fmtwrite(tt1, i);
  343. if (rc != 0) return(rc);
  344. rc = fmtwrite("\012", 1);
  345. if (rc != 0) return(rc);
  346.  
  347. if (indent > 0) for (i=0; i < indent; i++) {
  348.     rc = fmtwrite(" ", 1);
  349.     if (rc != 0) return(rc);
  350.     }
  351. i = strlen(tt2) - 1;
  352. if (i > width - indent) i = width - indent; 
  353. rc = fmtwrite(tt2, i);
  354. if (rc != 0) return(rc);
  355. rc = fmtwrite("\012", 1);
  356. return(rc);
  357. }
  358.  
  359. short skip(n)
  360. short n;
  361. {
  362. short i, rc;
  363.  
  364. if (n <= 0) return(0);
  365. for (i = 0; i < n; i++) {
  366.     rc = fmtwrite("\012", 1);
  367.     if (rc != 0) return(rc);
  368.     }
  369. return(0);
  370. }
  371.  
  372. short putline(void)
  373. {
  374. return (fmtwrite(currline, strlen(currline)));
  375. }
  376.  
  377. OSErr getline(void)
  378. {
  379. register short i, c, indent, width, tbsize;
  380. unsigned char tabflag;
  381.  
  382. memset(currline, 0, 130);
  383.  
  384. indent = cs.findent;
  385. if (indent > 63) indent = 0;
  386. if (indent > 0) memset(currline, 0x20, indent);
  387.  
  388. width = cs.fwidth;
  389. if (width == 0) width = ds.fwidth;
  390. if (width > 128) width = 128;
  391. if (width < 64) width = 64;
  392.  
  393. tabflag = 0;
  394. tbsize = cs.ftabsize;
  395. if (tbsize == 0) tbsize = ds.ftabsize;
  396. if (tbsize < 1) tbsize = 1;
  397. if (tbsize > 32) tbsize = 32;
  398.  
  399. for (i = indent; i < width; i ++) {
  400.     if (tabflag) {
  401.         if ((i-indent)%tbsize == 0) {
  402.             tabflag = 0;
  403.             c = newchar();
  404.             }
  405.         else c = 0x20;
  406.         }
  407.     else c = newchar();
  408.     if (c == 0x09) {
  409.         c = 0x20;
  410.         tabflag = 1;
  411.         }
  412.     if (c == 0x0a) break;
  413.     if (c == eofErr) {
  414.         if (i == indent) return(eofErr);
  415.         else break;
  416.         }
  417.     else if (c < 0) return(c);
  418.     currline[i] = c;
  419.     }
  420. if (!cs.splitflag) while ((c >= 0) && (c != 0x0a)) c = newchar();
  421. strcat(currline, "\012");
  422. return(0);
  423. }
  424.  
  425. short newchar(void)
  426. {
  427. long readact;
  428. register OSErr rc;
  429. register short c;
  430.  
  431. if (fbufptr == fbuflen) {
  432.     if (fileeof) return(eofErr);
  433.     readact = 512;
  434.     rc = FSRead(currfnum, &readact, fbuf);
  435.     fbufptr = 0;
  436.     fbuflen = readact;
  437.     if (rc == eofErr) {
  438.         fileeof = 1;
  439.         if (readact == 0) return(eofErr);
  440.         }
  441.     else if (rc != 0) {
  442.         fbuflen = 0;
  443.         fileeof = 1;
  444.         sprintf(setmsg2, "Error %d reading file", rc);
  445.         seterr();
  446.         return(rc);
  447.         }
  448.     }
  449. c = fbuf[fbufptr++];
  450. if (c == 0x0d) c = 0x0a;
  451. return(c);
  452. }
  453.  
  454. OSErr fmtwrite(s, len)
  455. unsigned char * s;
  456. short len;
  457. {
  458. short currlen;
  459.  
  460. if (countonly) {
  461.     filesize += len;
  462.     return(0);
  463.     }
  464.  
  465. while (len > 0) {
  466.     currlen = 512 - sbuflen;
  467.     if (currlen > len) currlen = len;
  468.     memcpy(sbuf+sbuflen, s, currlen);
  469.     s += currlen;
  470.     len -= currlen;
  471.     sbuflen += currlen;
  472.     if (sbuflen == 512) {
  473.         tcpwrite(sbuf, 512);
  474.         sbuflen = 0;
  475.         if (pend_conn == 0) return(8);
  476.         }
  477.     }
  478. return(0);
  479. }
  480.  
  481. short ctlline(void)
  482. {
  483. short len1, len2, tlen;
  484. unsigned char * tok1;
  485. unsigned char savechar;
  486. unsigned char newtitle[81];
  487.  
  488.  
  489. if (!cs.pascalflag) return(0);
  490.  
  491. tok1 = currline;
  492. while ((tok1[0] == ' ') || (tok1[0] == 0x09)) tok1++; 
  493. if ((tok1[0] == 0) || (tok1[0] == 0x0a)) return(0);
  494. len1 = 1;
  495. while ((tok1[len1] != ' ') && (tok1[len1] != 0x09)
  496.     && (tok1[len1] != 0x0a) && (tok1[len1] != 0)) len1++;
  497. savechar = tok1[len1];
  498. tok1[len1] = 0;
  499. if (0 == strcmp(tok1, "{EJECT}")) {
  500.     if ((savechar == ' ') || (savechar == 0x09)) {
  501.         len2 = len1 + 1;
  502.         while ((tok1[len2] == ' ') || (tok1[len2] == 0x09)) len2++; 
  503.         if ((tok1[len2] != 0) && (tok1[len2] != 0x0a)) {
  504.             tok1[len1] = savechar;
  505.             return(0);
  506.             }
  507.         }
  508.     return(1);
  509.     }
  510. else if (0 == strcmp(tok1, "{TITLE")) {
  511.     if ((savechar != ' ') && (savechar != 0x09)) {
  512.         tok1[len1] = savechar;
  513.         return(0);
  514.         }
  515.     len2 = len1 + 1;
  516.     tlen = 0;
  517.     while ((tok1[len2] != '}') && (tok1[len2] != 0x0a)
  518.         && (tok1[len2] != 0)) {
  519.         if (tlen < 79)  newtitle[tlen++] = tok1[len2];
  520.         len2++;
  521.         }
  522.     if (tok1[len2] != '}') {
  523.         tok1[len1] = savechar;
  524.         return(0);
  525.         }
  526.     len2++;
  527.     while ((tok1[len2] == ' ') || (tok1[len2] == 0x09)) len2++; 
  528.     if ((tok1[len2] != 0) && (tok1[len2] != 0x0a)) {
  529.         tok1[len1] = savechar;
  530.         return(0);
  531.         }
  532.     if (tlen > 0) memcpy(tt2, newtitle, tlen);
  533.     tt2[tlen] = 0x0a;
  534.     tt2[tlen+1] = 0;
  535.     return(1);
  536.     }
  537. else {
  538.     tok1[len1] = savechar;
  539.     return(0);
  540.     }
  541. }
  542.